package jmine.tec.utils.reflection.fast.asm;

public class Mock2Service {
    //
    // private String outro;
    //
    // private boolean validationRan;
    //
    // public Mock2Service(String a) {
    // assertNotNull(a);
    // }
    //
    // public void setCampoObrigatorio2(String outro) {
    // this.outro = outro;
    // }
    //
    // public void validate() {
    // this.validationRan = true;
    // }
    //
    // public boolean execute(String a, boolean campo) {
    // assertNotNull(this.outro);
    // assertTrue(this.validationRan);
    // assertTrue(campo);
    // return this.validationRan;
    // }

    /**
     * Asserts that a condition is true. If it isn't it throws an AssertionFailedError with the given message.
     */
    static public void assertTrue(String message, boolean condition) {
    }

    //
    // /**
    // * Asserts that a condition is true. If it isn't it throws an AssertionFailedError.
    // */
    static public void assertTrue(boolean condition) {
        assertTrue(null, condition);
    }

    //
    // /**
    // * Asserts that a condition is false. If it isn't it throws an AssertionFailedError with the given message.
    // */
    // static public void assertFalse(String message, boolean condition) {
    // assertTrue(message, !condition);
    // }
    //
    // /**
    // * Asserts that a condition is false. If it isn't it throws an AssertionFailedError.
    // */
    // static public void assertFalse(boolean condition) {
    // assertFalse(null, condition);
    // }
    //
    // /**
    // * Fails a test with the given message.
    // */

    //
    // /**
    // * Fails a test with no message.
    // */
    // static public void fail() {
    // fail(null);
    // }
    //
    // /**
    // * Asserts that two objects are equal. If they are not an AssertionFailedError is thrown with the given message.
    // */
    // static public void assertEquals(String message, Object expected, Object actual) {
    // }

    //
    // /**
    // * Asserts that two objects are equal. If they are not an AssertionFailedError is thrown.
    // */
    // static public void assertEquals(Object expected, Object actual) {
    // assertEquals(null, expected, actual);
    // }
    //
    // /**
    // * Asserts that two Strings are equal.
    // */
    // static public void assertEquals(String message, String expected, String actual) {
    // if (expected == null && actual == null)
    // return;
    // if (expected != null && expected.equals(actual))
    // return;
    // throw new ComparisonFailure(message, expected, actual);
    // }
    //
    // /**
    // * Asserts that two Strings are equal.
    // */
    // static public void assertEquals(String expected, String actual) {
    // assertEquals(null, expected, actual);
    // }
    //
    // /**
    // * Asserts that two doubles are equal concerning a delta. If they are not an AssertionFailedError is thrown with the given message. If
    // * the expected value is infinity then the delta value is ignored.
    // */
    // static public void assertEquals(String message, double expected, double actual, double delta) {
    // // handle infinity specially since subtracting to infinite values gives NaN and the
    // // the following test fails
    // }
    //
    // /**
    // * Asserts that two doubles are equal concerning a delta. If the expected value is infinity then the delta value is ignored.
    // */
    // static public void assertEquals(double expected, double actual, double delta) {
    // assertEquals(null, expected, actual, delta);
    // }
    //
    // /**
    // * Asserts that two floats are equal concerning a delta. If they are not an AssertionFailedError is thrown with the given message. If
    // * the expected value is infinity then the delta value is ignored.
    // */
    // static public void assertEquals(String message, float expected, float actual, float delta) {
    // handle infinity specially since subtracting to infinite values gives NaN and the
    // the following test fails
    // }

    //
    // /**
    // * Asserts that two floats are equal concerning a delta. If the expected value is infinity then the delta value is ignored.
    // */
    // static public void assertEquals(float expected, float actual, float delta) {
    // assertEquals(null, expected, actual, delta);
    // }
    //
    // /**
    // * Asserts that two longs are equal. If they are not an AssertionFailedError is thrown with the given message.
    // */
    // static public void assertEquals(String message, long expected, long actual) {
    // assertEquals(message, new Long(expected), new Long(actual));
    // }
    //
    // /**
    // * Asserts that two longs are equal.
    // */
    // static public void assertEquals(long expected, long actual) {
    // assertEquals(null, expected, actual);
    // }
    //
    // /**
    // * Asserts that two booleans are equal. If they are not an AssertionFailedError is thrown with the given message.
    // */
    // static public void assertEquals(String message, boolean expected, boolean actual) {
    // assertEquals(message, new Boolean(expected), new Boolean(actual));
    // }
    //
    // /**
    // * Asserts that two booleans are equal.
    // */
    // static public void assertEquals(boolean expected, boolean actual) {
    // assertEquals(null, expected, actual);
    // }
    //
    // /**
    // * Asserts that two bytes are equal. If they are not an AssertionFailedError is thrown with the given message.
    // */
    // static public void assertEquals(String message, byte expected, byte actual) {
    // assertEquals(message, new Byte(expected), new Byte(actual));
    // }
    //
    // /**
    // * Asserts that two bytes are equal.
    // */
    // static public void assertEquals(byte expected, byte actual) {
    // assertEquals(null, expected, actual);
    // }

    //
    // /**
    // * Asserts that two chars are equal. If they are not an AssertionFailedError is thrown with the given message.
    // */
    static public void assertEquals(String message, char expected, char actual) {
        assertEquals(message, new Character(expected), new Character(actual));
    }

    //
    // /**
    // * Asserts that two chars are equal.
    // */
    // static public void assertEquals(char expected, char actual) {
    // assertEquals(null, expected, actual);
    // }
    //
    // /**
    // * Asserts that two shorts are equal. If they are not an AssertionFailedError is thrown with the given message.
    // */
    // static public void assertEquals(String message, short expected, short actual) {
    // assertEquals(message, new Short(expected), new Short(actual));
    // }

    //
    // /**
    // * Asserts that two shorts are equal.
    // */
    static public void assertEquals(short expected, short actual) {
    }
    //
    // /**
    // * Asserts that two ints are equal. If they are not an AssertionFailedError is thrown with the given message.
    // */
    // static public void assertEquals(String message, int expected, int actual) {
    // assertEquals(message, new Integer(expected), new Integer(actual));
    // }
    //
    // /**
    // * Asserts that two ints are equal.
    // */
    // static public void assertEquals(int expected, int actual) {
    // assertEquals(null, expected, actual);
    // }
    //
    // /**
    // * Asserts that an object isn't null.
    // */
    // static public void assertNotNull(Object object) {
    // assertNotNull(null, object);
    // }
    //
    // /**
    // * Asserts that an object isn't null. If it is an AssertionFailedError is thrown with the given message.
    // */
    // static public void assertNotNull(String message, Object object) {
    // assertTrue(message, object != null);
    // }
    //
    // /**
    // * Asserts that an object is null.
    // */
    // static public void assertNull(Object object) {
    // assertNull(null, object);
    // }
    //
    // /**
    // * Asserts that an object is null. If it is not an AssertionFailedError is thrown with the given message.
    // */
    // static public void assertNull(String message, Object object) {
    // assertTrue(message, object == null);
    // }
    //
    // /**
    // * Asserts that two objects refer to the same object. If they are not an AssertionFailedError is thrown with the given message.
    // */
    // static public void assertSame(String message, Object expected, Object actual) {
    // if (expected == actual)
    // return;
    // }
    //
    // /**
    // * Asserts that two objects refer to the same object. If they are not the same an AssertionFailedError is thrown.
    // */
    // static public void assertSame(Object expected, Object actual) {
    // assertSame(null, expected, actual);
    // }
    //
    // /**
    // * Asserts that two objects refer to the same object. If they are not an AssertionFailedError is thrown with the given message.
    // */
    // static public void assertNotSame(String message, Object expected, Object actual) {
    // }
    //
    // /**
    // * Asserts that two objects refer to the same object. If they are not the same an AssertionFailedError is thrown.
    // */
    // static public void assertNotSame(Object expected, Object actual) {
    // assertNotSame(null, expected, actual);
    // }
    //
    // static String format(String message, Object expected, Object actual) {
    // String formatted = "";
    // if (message != null)
    // formatted = message + " ";
    // return formatted + "expected:<" + expected + "> but was:<" + actual + ">";
    // }

}
